package com.yidu.qianfeng.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yidu.qianfeng.common.bean.company.*;
import com.yidu.qianfeng.mapper.*;
import com.yidu.qianfeng.service.EmployeeServiceInter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 田舒蓉
 * 员工管理  分站管理
 */

@Service
public class EmployeeServiceImpl implements EmployeeServiceInter {

    @Qualifier("employeeMapper")
    @Autowired
    EmployeeMapper employeeMapper;

    @Resource(name = "modelAuthServiceImpl")
    ModelAuthServiceImpl modelAuthService;//员工模块权限关联业务实现

    @Resource(name = "empAuthServiceImpl")
    EmpAuthServiceImpl empAuthService;//员工页面权限关联业务实现

    @Resource(name = "empAuthMapper")
    EmpAuthMapper empAuthMapper;

    @Resource(name = "modelAuthMapper")
    ModelAuthMapper modelAuthMapper;

    @Resource(name = "empPageMapper")
    private EmpPageMapper empPageMapper;

    @Resource(name = "empModelMapper")
    private EmpModelMapper empModelMapper;

    @Override
    public List<EmpPage> queryEmpPage() {
        return employeeMapper.queryEmpPage();
    }

    /**
     * 查询员工
     * @return
     */
    @Override
    public List<EmpInfo> queryEmpInfo() {
        return employeeMapper.queryEmpInfo();
    }

    /**
     * 新增员工
     * @param empInfo 员工信息
     * @param empPageAuthIds 员工页面权限
     * @param empModelAuthIds 员工模块权限
     * @return
     */
    @Override
    @Transactional
    public int saveEmployee(EmpInfo empInfo, List<String> empPageAuthIds, List<String> empModelAuthIds) {
        //新增员工加密
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        empInfo.setEmpPassword(passwordEncoder.encode(empInfo.getPassword()));
        //新增员工信息
        int saveEmployee = employeeMapper.saveEmployee(empInfo);
        //员工模块权限关联集合
        List<ModelAuth> modelAuths = new ArrayList<ModelAuth>();
        //循环创建员工模块权限关联实体
        for (String empModelAuth : empModelAuthIds) {
            ModelAuth modelAuth = new ModelAuth();
            modelAuth.setMaMauthId(Integer.parseInt(empModelAuth));
            modelAuth.setMaEmpAccount(empInfo.getEmpAccount());
            //加入集合
            modelAuths.add(modelAuth);
        }
        //判断模块关联集合非等于0
        if (modelAuths.size() != 0){
            //批量新增员工页面权限关联
            modelAuthService.saveBatch(modelAuths);
        }

        //员工页面权限关联集合
        List<EmpAuth> empAuths = new ArrayList<EmpAuth>();
        //循环创建员工页面权限关联实体
        for (String empPageAuthId : empPageAuthIds) {
            EmpPage empPage = empPageMapper.selectById(empPageAuthId);
            boolean isNotHasMauth = true;
            //循环创建员工模块权限关联实体
            for (String empModelAuth : empModelAuthIds) {
                if (empModelAuth.equals(empPage.getPauthMauthId())){
                    isNotHasMauth = false;
                    break;
                }
            }
            if (isNotHasMauth){
                EmpAuth empAuth = new EmpAuth();
                empAuth.setEaPauthId(Integer.parseInt(empPageAuthId));
                empAuth.setEaEmpAccount(empInfo.getEmpAccount());
                //加入集合
                empAuths.add(empAuth);
            }
        }

        //判断页面关联集合非等于0
        if (empAuths.size() != 0){
            //批量新增员工页面权限关联
            empAuthService.saveBatch(empAuths);
        }
        //返回新增结果
        return saveEmployee;
    }

    /**
     * 修改员工
     * @param empInfo 员工信息
     * @param empPageAuthIds 员工页面权限
     * @param empModelAuthIds 员工模块权限
     * @return
     */
    @Override
    @Transactional
    public int updateEmployee(EmpInfo empInfo, List<String> empPageAuthIds,  List<String> empModelAuthIds){
        String empPassword = employeeMapper.selectById(empInfo.getEmpAccount()).getEmpPassword();
        empInfo.setEmpPassword(empPassword);

        //修改员工信息
        Integer update = employeeMapper.updateById(empInfo);

        if (update == 0){
            return update;
        }

        //查询出员工模块权限关联集合
        QueryWrapper<ModelAuth> wrapper = new QueryWrapper<>();
        wrapper.eq("ma_emp_account", empInfo.getEmpAccount());
        modelAuthService.remove(wrapper);

        //员工模块权限关联集合
        List<ModelAuth> addModelAuths = new ArrayList<ModelAuth>();
        //循环创建员工模块权限关联实体
        for (String empModelAuth : empModelAuthIds) {
            ModelAuth modelAuth = new ModelAuth();
            modelAuth.setMaMauthId(Integer.parseInt(empModelAuth));
            modelAuth.setMaEmpAccount(empInfo.getEmpAccount());
            //加入集合
            addModelAuths.add(modelAuth);
        }

        if (addModelAuths.size() != 0){
            modelAuthService.saveBatch(addModelAuths);
        }


        //员工页面权限关联集合
        List<EmpAuth> empAuths = new ArrayList<EmpAuth>();

        QueryWrapper<EmpAuth> pageWrapper = new QueryWrapper<>();
        pageWrapper.eq("ea_emp_account", empInfo.getEmpAccount());
        empAuthService.remove(pageWrapper);

        //循环创建员工页面权限关联实体
        for (String empPageAuthId : empPageAuthIds) {
            EmpPage empPage = empPageMapper.selectById(empPageAuthId);
            boolean isNotHasMauth = true;
            //循环创建员工模块权限关联实体
            for (String empModelAuth : empModelAuthIds) {
                if (empModelAuth.equals(empPage.getPauthMauthId())){
                    isNotHasMauth = false;
                    break;
                }
            }
            if (isNotHasMauth){
                EmpAuth empAuth = new EmpAuth();
                empAuth.setEaPauthId(Integer.parseInt(empPageAuthId));
                empAuth.setEaEmpAccount(empInfo.getEmpAccount());
                //加入集合
                empAuths.add(empAuth);
            }
        }
        if (empAuths.size() != 0){
            empAuthService.saveBatch(empAuths);
        }


        return update;
    }

    /**
     * 根据员工账号查询员工
     * @param empAccount 员工账号
     * @return
     */
    @Override
    public EmpInfo querybyEmpId(String empAccount) {
        EmpInfo empInfo = employeeMapper.querybyEmpId(empAccount);

        return empInfo;
    }

    /**
     * 删除员工
     * @param empAccount 根据员工账号删除
     * @return
     */
    @Override
    @Transactional
    public int deleteEmp(String empAccount) {

        //查询出员工模块权限关联集合
        QueryWrapper<ModelAuth> modelWrapper = new QueryWrapper<>();
        modelWrapper.eq("ma_emp_account", empAccount);
        modelAuthService.remove(modelWrapper);

        QueryWrapper<EmpAuth> pageWrapper = new QueryWrapper<>();
        pageWrapper.eq("ea_emp_account", empAccount);
        empAuthService.remove(pageWrapper);

        return employeeMapper.deleteEmp(empAccount);
    }

    /**
     * 查询分站
     * @return
     */
    @Override
    public List<Subst> querySubst() {
        return employeeMapper.querySubst();
    }

    /**
     * 新增分站
     * @param subst
     * @return
     */
    @Override
    public int saveSubst(Subst subst) {
        return employeeMapper.saveSub(subst);
    }

    /**
     * 删除分站
     * @param substID
     * @return
     */
    @Override
    public int removeSub(String substID) {
        return employeeMapper.removeSub(substID);
    }

    /**
     * 根据id查询分站
     * @param substID
     * @return
     */
    @Override
    public Subst queryById(String substID) {
        return employeeMapper.queryById(substID);
    }


    /**
     * 修改分站
     * @param subst
     * @return
     */
    @Override
    public int updateSubst(Subst subst) {
        return employeeMapper.updateSubst(subst);
    }

}



/*
    List<EmpAuth> empAuths = new ArrayList<EmpAuth>();
//循环创建员工页面权限关联实体
        for (String empPageAuthId : empPageAuthIds) {
                EmpPage empPage = empPageMapper.selectById(empPageAuthId);
                boolean isNotHasMauth = true;
                //循环创建员工模块权限关联实体
                for (String empModelAuth : empModelAuthIds) {
                if (empModelAuth.equals(empPage.getPauthMauthId())){
                isNotHasMauth = false;
                break;
                }
                }
                if (isNotHasMauth){
                EmpAuth empAuth = new EmpAuth();
                empAuth.setEaPauthId(Integer.parseInt(empPageAuthId));
                empAuth.setEaEmpAccount(empInfo.getEmpAccount());
                //加入集合
                empAuths.add(empAuth);
                }
                }

                //判断页面关联集合非等于0
                if (empAuths.size() != 0){
                //批量新增员工页面权限关联
                empAuthService.saveBatch(empAuths);
                }

*/
